
#include <principal.h>

using namespace std;
using namespace Gtk::Menu_Helpers;

/**
 *
 */
COLUNASR::COLUNASR()
	{
	int i;/**<Variável local para contagem dos campos*/
	this->n_campos = 7;
	add(codigo);
	for(i=0; i< this->n_campos; i++)
		{
		add(this->campo[i]);
		}
	}

/**
 *
 */
COLUNASR::~COLUNASR()
	{
			
	}

/**
 *
 */
PRINCIPAL::PRINCIPAL()
	{
	Gtk::HBox *HU;
	Gtk::Label *LU;
	this->data_hoje = new char[15];
	this->data_hoje = hoje();
	ponteiro_icon=Gdk::Pixbuf::create_from_file ("img/siscap.ico");
	Usuario = new Gtk::Window();
	Usuario->set_title (Glib::ustring("..::Usuário::.."));
	Usuario->signal_hide().connect (sigc::bind<Gtk::Window *>(sigc::mem_fun(*this, &PRINCIPAL::sair),Usuario));
	Usuario->set_position(Gtk::WIN_POS_CENTER);
	Usuario->set_icon(ponteiro_icon);
	HU = new Gtk::HBox(false,0);
	LU = new Gtk::Label(Glib::ustring("Identifique-se: "));
	Nome = new Gtk::Entry();
	Nome->signal_changed ().connect(sigc::bind<Gtk::Entry *>(sigc::mem_fun(*this,&PRINCIPAL::maiusculo),Nome));
	Nome->signal_activate ().connect(sigc::mem_fun(*this,&PRINCIPAL::Janela_Principal));
	HU->pack_start(*LU,false,false,0);
	HU->pack_start(*Nome,false,false,0);
	Usuario->add(*HU);
	Usuario->show_all();
	}

/**
 * Janela principal do sistema
 */
void PRINCIPAL::Janela_Principal ()
	{
	Gtk::Frame *FRAME;
	int i;
	this->controle_historico=true;
	for(i=1;i<7;i++)
		{
		this->controle[i]=true;
		}
	usuario.clear();
	usuario = Nome->get_text();
	sair(Usuario);
	conexao =  new BANCOPG(CONF_FILE);
	Principal = new Gtk::Window();
	Principal->set_title(Glib::ustring("SisCAP - Sistema de Controle de Apiários"));
    Principal->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
    Principal->set_position(Gtk::WIN_POS_CENTER);
    Principal->set_default_size(600, 500);
	Principal->set_icon(ponteiro_icon);
	Principal->signal_show ().connect(sigc::mem_fun(*this,&PRINCIPAL::resumo));
	Principal->signal_hide().connect (sigc::bind<Gtk::Window *>(sigc::mem_fun(*this, &PRINCIPAL::sair),Principal));
	//maximize();
		
    Box_Principal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI 
    Box_Principal.set_spacing(0);				//ESPAÇAMENTO ENTRE BOX FILHOS
	string status;
	status.clear();
	status = "SISCAP - ";
	status.append(data_formatada(this->data_hoje,2));
	status += " - ";
	status.append(agora());
	this->statusbar1 = this->BarraStatus1.push(Glib::ustring(status));
	this->Box_Principal.pack_end(this->BarraStatus1,false,true,0);
	Glib::signal_timeout().connect(sigc::mem_fun(*this,&PRINCIPAL::run), 1000);

	//BOX ONDE COLOCAREMOS OS ITENS DO MENU	
	Box_Menu.set_homogeneous(true);
	Box_Menu.set_spacing(0);			//INSERINDO A IMAGEM NA TELA INICIAL	
			
	Box_Image.set_homogeneous(false);
	Box_Image.set_spacing(0);
	Logo = new Gtk::Image("img/logo.png");
	FRAME = new Gtk::Frame("Resumo Geral");
	Dados = new Gtk::TreeView ();
	Dados->set_size_request (300,500);
	arvore_ref = Gtk::ListStore::create(arvore);
	Dados->set_model(arvore_ref);
	Dados->remove_all_columns ();
	Dados->append_column (Glib::ustring("Descrição"),arvore.campo[0]);
	Dados->append_column (Glib::ustring("Dados"),arvore.campo[1]);
	SW.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	SW.add(*Dados);
	FRAME->add(SW);
	Box_Image.pack_start(*FRAME,false,false,0);
	
	//Barra de Menus
  	menu_barra = Gtk::manage(new Gtk::MenuBar());

	//Menu: Arquivos
		{
		Gtk::Menu::MenuList& menulist = MenuArquivo.items();
		menulist.push_back( MenuElem(Glib::ustring("_Configurações"), MenuArquivoConf) );
		menulist.push_back( MenuElem(Glib::ustring("_Importação"), MenuArquivoImp) );
		menulist.push_back(SeparatorElem());
		menulist.push_back(MenuElem("_Sair",Gtk::AccelKey("<alt>F4"),sigc::bind<Gtk::Window *>(sigc::mem_fun(*this, &PRINCIPAL::sair),Principal)));
		}
	editar_conexao(true);	//INCIALIZA JANELA ANTES
	//SubMenu: Configurações
		{
		Gtk::Menu::MenuList& menulist = MenuArquivoConf.items();
		menulist.push_back(MenuElem("_Editar arquivo", Gtk::AccelKey("<control>N"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::editar_conexao),false)));
	  	menulist.push_back(MenuElem(Glib::ustring("_Teste de Conexão"),Gtk::AccelKey("<control>L"),sigc::mem_fun(*this, &PRINCIPAL::testar_conexao)));
		}	
	//SubMenu: Importação
		{
		Gtk::Menu::MenuList& menulist = MenuArquivoImp.items();
		menulist.push_back(MenuElem(Glib::ustring("_Apiário"),  MenuImpApiario));
		menulist.push_back(MenuElem(Glib::ustring("_Colméia"),Gtk::AccelKey("<alt>C"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),3)));
		menulist.push_back(MenuElem("_Planilha",Gtk::AccelKey("<alt>P"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),4)));
		menulist.push_back(MenuElem("C_odigo Cidade",Gtk::AccelKey("<alt>O"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::checar),5)));
		menulist.push_back(MenuElem(Glib::ustring("_Região")));
		menulist.push_back(MenuElem(Glib::ustring("R_el Api-Colm"),Gtk::AccelKey("<alt>E"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),6)));
		menulist.push_back(MenuElem(Glib::ustring("_Histórico"),Gtk::AccelKey("<alt>H"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),7)));
		}

	//Submenu Apiário
		{
		Gtk::Menu::MenuList& menulist = MenuImpApiario.items();
		menulist.push_back(MenuElem(Glib::ustring("Apiários"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),2)));
		menulist.push_back(MenuElem("Florada",sigc::bind(sigc::mem_fun(this, &PRINCIPAL::importar),1)));
		}			
	//Menu: Cadastro
		{
		Gtk::Menu::MenuList& menulist = MenuCadastro.items();
		menulist.push_back(MenuElem("_Apiários", Gtk::AccelKey("<control>A"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),1)));
		menulist.push_back(MenuElem("_Florada", Gtk::AccelKey("<control>F"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),7)));	
		menulist.push_back(MenuElem("_Colméias", Gtk::AccelKey("<control>C"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),2)));
		menulist.push_back(MenuElem("_Planilhas", Gtk::AccelKey("<control>P"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),3)));			
		menulist.push_back(MenuElem(Glib::ustring("_Regiões"),Gtk::AccelKey("<control>R"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),4)));
		menulist.push_back(MenuElem("_Siglas", Gtk::AccelKey("<control>S"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),5)));	
		menulist.push_back(MenuElem("A_belha Rainha", Gtk::AccelKey("<control>B"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),6)));	
		}

	//Menu: Relatório
		{
		Gtk::Menu::MenuList& menulist = MenuRelatorio.items();
		menulist.push_back(MenuElem("_Apiários", Gtk::AccelKey("<control>A"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),1)));
		menulist.push_back(MenuElem("_Florada", Gtk::AccelKey("<control>F"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),7)));	
		menulist.push_back(MenuElem("_Colméias", Gtk::AccelKey("<control>C"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),2)));
		menulist.push_back(MenuElem("_Planilhas", Gtk::AccelKey("<control>P"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),3)));			
		menulist.push_back(MenuElem(Glib::ustring("_Regiões"),Gtk::AccelKey("<control>R"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),4)));
		menulist.push_back(MenuElem("_Siglas", Gtk::AccelKey("<control>S"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),5)));	
		menulist.push_back(MenuElem("A_belha Rainha", Gtk::AccelKey("<control>B"),sigc::bind(sigc::mem_fun(this, &PRINCIPAL::cadastro),6)));	
		}

 			
  //BOX ONDE COLOCAREMOS OS ITENS DO APIÁRIO
	menu_barra->items().push_back(MenuElem(Glib::ustring("_Arquivo"),MenuArquivo));
	menu_barra->items().push_back(MenuElem(Glib::ustring("_Cadastro"),MenuCadastro));
	menu_barra->items().push_back(MenuElem(Glib::ustring("_Histórico"),Gtk::AccelKey("<control>H"),sigc::mem_fun(*this, &PRINCIPAL::historico)));
	menu_barra->items().push_back(MenuElem(Glib::ustring("_Relatório"),Gtk::AccelKey("<alt>R"),sigc::mem_fun(*this, &PRINCIPAL::historico)));
	menu_barra->items().push_back(MenuElem(Glib::ustring("_Sobre"),Gtk::AccelKey("<alt>S"),sigc::mem_fun(*this, &PRINCIPAL::info)));
			
  	Box_Conteudo.set_homogeneous(false);
  	Box_Conteudo.set_spacing(0);


	//ORGANIZANDO A BOX PRINCIPAL:
 	Box_Menu.pack_start(*menu_barra,true,true,0);
	
  	Box_Principal.pack_start(Box_Menu,false,false,0);

	Box_Principal.pack_start(Box_Image,true,true,0);
			
  	Box_Principal.pack_start(Box_Conteudo,true,true,0);
	
 	Principal->add(Box_Principal);

 	Principal->show_all();
	Gtk::Main::run(*Principal);
 	}

/**
 *
 */
PRINCIPAL::~PRINCIPAL()
  	{
	if (conexao->conectado)
		{
		delete conexao;
		}
  	}

/**
 *
 */
void PRINCIPAL::sair(Gtk::Window *j)
	{

	j->hide(); //Fechar janela
	}

/**
 * \param opc
 */
void PRINCIPAL::aviso(int opc)
	{
	cout << opc << endl;
	}

/**
 * \param opc
 */
void PRINCIPAL::cadastro(int opc)
	{
	if(controle[opc])
		{
		cad = new CADASTRO(opc, &controle[opc],conexao);
		switch(opc)
			{
			case 1:
				{
				Gtk::Main::run(cad->Apiarios);
				cad->Apiarios.show_all();
				break;
				}
			case 2:
				{
				cad->Colmeias->show_all();
				Gtk::Main::run(*cad->Colmeias);
				break;
				}
			case 3:
				{
				cad->Planilhas->show_all();
				Gtk::Main::run(*cad->Planilhas);
				break;
				}
			case 4:
				{
				Gtk::Main::run(cad->Regioes);
				cad->Regioes.show_all();
				break;
				}
			case 5:
				{
				Gtk::Main::run(cad->Siglas);
				cad->Siglas.show_all();
				break;
				}
			case 6:
				{
				cad->Abelha_Rainha->show_all();
				Gtk::Main::run(*cad->Abelha_Rainha);
				break;
				}
			case 7:
				{
				Gtk::Main::run(cad->Florada);
				cad->Florada.show_all();
				break;
				}	
			}
		}
	}

/**
 *
 */
void PRINCIPAL::historico() 
	{
	if(controle_historico)
		{
		HISTORICO hist(&this->controle_historico, this->conexao);
		Gtk::Main::run(hist.Historico_Geral);
		hist.Historico_Geral.show_all();
		}
	}

/**
 * \param opc
 */
void PRINCIPAL::importar(int opc)
	{
	IMPORT *arquivo;

	arquivo = new IMPORT(opc,Principal,this->conexao);
	}

/**
 *
 */
void PRINCIPAL::info()
	{
	Gtk::MessageDialog dialog(*Principal, Glib::ustring("Informações do Software"));
	dialog.set_secondary_text("Software desenvolvido por Jónison A. dos Santos. Com contribuição de  Alcione Ferreira, Jong Wan Silva e Rodolfo.");
	dialog.set_position(Gtk::WIN_POS_CENTER);
	dialog.run();
		
	}

/**
 *
 */
void PRINCIPAL::testar_conexao()
	{
	if(conexao->conectado)
		{
		Gtk::MessageDialog dialog(*Principal, "Banco conectado com sucesso", false, Gtk::MESSAGE_INFO);
		dialog.set_position(Gtk::WIN_POS_CENTER);
		dialog.run();
		}
	else
		{
		Gtk::MessageDialog dialog(*Principal, Glib::ustring("Falha na conexão"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring(conexao->mensagem));
		dialog.set_position(Gtk::WIN_POS_CENTER);
		dialog.run();
		}
	}

/**
 * \param inicializar
 */
void PRINCIPAL::editar_conexao(bool inicializar)
	{	
	char sgbd[16];

	if (inicializar) 
		{		
		editar.set_title(Glib::ustring("Configuração Base de Dados"));
		editar.resize(300,200);		
		editar.add(Box_Conexao);
		Box_Conexao.pack_start(tabela_fixa);
		Box_Conexao.pack_start(caixa_botao, Gtk::PACK_SHRINK);
		
		//LABEL DOS CAMPOS
		labHost.set_label("Host");
		labBanco.set_label("Banco");
		labUser.set_label(Glib::ustring("Usuário"));
		labSenha.set_label("Senha");
		labSGBD.set_label("SSL");
		
		//COLOCANDO VALORES NO ENTRY
		entHost.set_text(conexao->host);
		entBanco.set_text(conexao->banco);
		entUser.set_text(conexao->user);
		entSenha.set_text(conexao->senha);
		entSenha.set_visibility(false);
		entSenha.set_invisible_char('*');
	 	sprintf(sgbd, "%d", conexao->tipo);
		entSGBD.set_text(sgbd);
		
		//BOTAO ALTERAR		
		caixa_botao.pack_start(botao_alterar, Gtk::PACK_SHRINK);
		caixa_botao.set_border_width(5);
		caixa_botao.set_layout(Gtk::BUTTONBOX_END);
		botao_alterar.set_label("Alterar");
		botao_alterar.signal_clicked().connect(sigc::mem_fun(*this, &PRINCIPAL::alterar_conexao));	
		
		//COLOCA OS LABELS NA TABELA
		tabela_fixa.put(labHost,10,10);
		tabela_fixa.put(labBanco,10,40);
		tabela_fixa.put(labUser,10,70);
		tabela_fixa.put(labSenha,10,100);
		tabela_fixa.put(labSGBD,10,130);
		
		//COLOCA OS ENTRYS NA TABELA
		tabela_fixa.put(entHost,120,10);
		tabela_fixa.put(entBanco,120,40);
		tabela_fixa.put(entUser,120,70);
		tabela_fixa.put(entSenha,120,100);
		tabela_fixa.put(entSGBD,120,130);
		}
	else
		{	
		editar.show_all();	
		Gtk::Main::run(editar);
		}	
		
	}

/**
 *
 */
void PRINCIPAL::alterar_conexao()
	{
	conf_escreve.open(CONF_FILE);
	
	conexao->host = entHost.get_text();
	conexao->banco = entBanco.get_text();
	conexao->user = entUser.get_text();
	conexao->senha = entSenha.get_text();
	conexao->tipo = atoi(entSGBD.get_text().c_str());
	
	conf_escreve << "host=" 	<< conexao->host	<< endl;
	conf_escreve << "banco=" 	<< conexao->banco	<< endl;
	conf_escreve << "usuario="	<< conexao->user 	<< endl;
	conf_escreve << "senha=" 	<< conexao->senha	<< endl;
	conf_escreve << "sgbd=" 	<< conexao->tipo	<< endl;
	conf_escreve.close();	
	
	conexao->conectar();
	
	editar.hide();
	}

/**
 * \param x
 */
void PRINCIPAL :: checar(int x)
	{
	string SQL;
	int cidade,apiario,i,j,num;
	char *sql, *aux_convert;
	string  *apiario_cod, *siglas;
	unsigned int *cidade_cod;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	SQL.clear();
	SQL = "select cod_cid from cadastro.apiarios group by cod_cid";
	sql = new char[SQL.length()+1];
	strcpy(sql, SQL.c_str());
	conexao->executar(sql);
	delete sql;
	cidade = conexao->registros;
	cidade_cod = new unsigned int[cidade];
	conexao->resultado();
	for(ir=conexao->resultados.begin();ir < conexao->resultados.end();ir++)
		{
		linha = *ir;
		cidade_cod[i] = atoi(linha.at(0).c_str());
		}
	cout << cidade << endl;
    cout << cidade_cod[0] << endl;
	int k;
	for(k=0;k<cidade;k++)
		{
		SQL.clear();
		SQL = "select apiarios.id_api, siglas.sigla from cadastro.apiarios natural join cadastro.siglas  where apiarios.cod_cid=";
		aux_convert =  new char[32];
		sprintf(aux_convert,"%d",cidade_cod[k]);
		SQL.append (aux_convert);
		SQL += " order by id_api";
		sql = new char[SQL.length()+1];
		strcpy (sql,SQL.c_str());
		conexao->executar(sql);
		delete sql;
		apiario = conexao->registros;
		apiario_cod = new string[apiario];
		siglas = new string[apiario];
		conexao->resultado();
		for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
		  	{
			linha = *ir;
		  	apiario_cod[i] = linha.at(0);
		  	siglas[i] = linha.at(1);
		  	}
		conexao->executar("begin;");
		for(j=0;j<apiario;j++)
			{
			num = j+1;
			SQL.clear();
			SQL = "update cadastro.apiarios set codigo='";
			aux_convert = new char[32];
			sprintf(aux_convert,"%s%03d",siglas[j].c_str(),num);
			SQL.append(aux_convert);
			delete aux_convert;
			SQL += "', flag=";
			aux_convert = new char[32];
			sprintf(aux_convert,"%d",num);
			SQL.append (aux_convert);
			delete aux_convert;
			SQL += " where id_api="+apiario_cod[j]+ ";";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str ());
			cout<<sql<<endl;
			conexao->executar(sql);	
			delete sql;
			//cout<<this->mensagem<<endl;
			}
		conexao->executar("commit;");
		}
	}

/**
 * Este método é executado a cada segundo para atualizar a hora do relógio na
 * PRINCIPAL::BarraStatus1.
 */
bool PRINCIPAL::run()
	{
	string status;
	status.clear();
	status = "SISCAP - Usuário: "+usuario+" - ";
	status.append(data_formatada(this->data_hoje,2));
	status += " - ";
	status.append(agora());
	this->statusbar1 = this->BarraStatus1.push(Glib::ustring(status));
	return true;
	}

/**
 *  
 */
void PRINCIPAL::resumo()
	{
	char *sql, *aux;
	string SQL, AUX;
	int registro, colunas, i, it;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	arvore_ref = Gtk::ListStore::create(arvore);
	Dados->set_model(arvore_ref);
	// Colmeias select count(id_colmeia) from historico.producaotemp
	SQL.clear();
	SQL = "select count(id_colmeia) from historico.producaotemp";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	conexao->executar(sql);
	AUX.clear();
	AUX = "0";
	if (conexao->registros > 0)
		{
		conexao->resultado();
		linha.clear();
		linha = conexao->resultados.at(0);
		AUX.clear();
		AUX = linha.at(0);
		}
	celula = *(arvore_ref->append());
	celula[arvore.campo[0]] = Glib::ustring("Colméias");
	celula[arvore.campo[1]] = AUX;
	celula = *(arvore_ref->append());
	celula[arvore.campo[0]] = "";
	celula[arvore.campo[1]] = "";
	celula = *(arvore_ref->append());
	celula[arvore.campo[0]] = Glib::ustring("Região");
	celula[arvore.campo[1]] = "Apiários";
	//Regioes
	//select municipio.nome, count(id_api) from cadastro.apiarios inner join cadastro.municipio on apiarios.cod_cid=municipio.cod_cid group by municipio.nome order by municipio.nome
	SQL.clear();
	SQL = "select municipio.nome, count(id_api) from cadastro.apiarios inner join cadastro.municipio on apiarios.cod_cid=municipio.cod_cid group by municipio.nome order by municipio.nome";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	conexao->executar(sql);
	if (conexao->registros > 0)
		{
		conexao->resultado();
		for (ir = conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
			{
			linha = *ir;
			celula = *(arvore_ref->append());
			celula[arvore.campo[0]] = Glib::ustring(linha.at(0));
			celula[arvore.campo[1]] = Glib::ustring(linha.at(1));
			}
		}

	//Atualizando
	Dados->remove_all_columns ();
	Dados->append_column (Glib::ustring("Descrição"),arvore.campo[0]);
	Dados->append_column (Glib::ustring("Dados"),arvore.campo[1]);
	}

void PRINCIPAL::maiusculo (Gtk::Entry *e)
	{
	string aux;
	aux.clear();
	aux = e->get_text();
	e->set_text (Glib::ustring(ParaMaiusculos(aux)));	
	}